home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / lib / python2.5 / markupbase.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-29  |  10KB  |  405 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. '''Shared support for scanning document type declarations in HTML and XHTML.
  5.  
  6. This module is used as a foundation for the HTMLParser and sgmllib
  7. modules (indirectly, for htmllib as well).  It has no documented
  8. public API and should not be used directly.
  9.  
  10. '''
  11. import re
  12. _declname_match = re.compile('[a-zA-Z][-_.a-zA-Z0-9]*\\s*').match
  13. _declstringlit_match = re.compile('(\\\'[^\\\']*\\\'|"[^"]*")\\s*').match
  14. _commentclose = re.compile('--\\s*>')
  15. _markedsectionclose = re.compile(']\\s*]\\s*>')
  16. _msmarkedsectionclose = re.compile(']\\s*>')
  17. del re
  18.  
  19. class ParserBase:
  20.     '''Parser base class which provides some common support methods used
  21.     by the SGML/HTML and XHTML parsers.'''
  22.     
  23.     def __init__(self):
  24.         if self.__class__ is ParserBase:
  25.             raise RuntimeError('markupbase.ParserBase must be subclassed')
  26.         
  27.  
  28.     
  29.     def error(self, message):
  30.         raise NotImplementedError('subclasses of ParserBase must override error()')
  31.  
  32.     
  33.     def reset(self):
  34.         self.lineno = 1
  35.         self.offset = 0
  36.  
  37.     
  38.     def getpos(self):
  39.         '''Return current line number and offset.'''
  40.         return (self.lineno, self.offset)
  41.  
  42.     
  43.     def updatepos(self, i, j):
  44.         if i >= j:
  45.             return j
  46.         
  47.         rawdata = self.rawdata
  48.         nlines = rawdata.count('\n', i, j)
  49.         if nlines:
  50.             self.lineno = self.lineno + nlines
  51.             pos = rawdata.rindex('\n', i, j)
  52.             self.offset = j - pos + 1
  53.         else:
  54.             self.offset = self.offset + j - i
  55.         return j
  56.  
  57.     _decl_otherchars = ''
  58.     
  59.     def parse_declaration(self, i):
  60.         rawdata = self.rawdata
  61.         j = i + 2
  62.         if not rawdata[i:j] == '<!':
  63.             raise AssertionError, 'unexpected call to parse_declaration'
  64.         if rawdata[j:j + 1] == '>':
  65.             return j + 1
  66.         
  67.         if rawdata[j:j + 1] in ('-', ''):
  68.             return -1
  69.         
  70.         n = len(rawdata)
  71.         if rawdata[j:j + 2] == '--':
  72.             return self.parse_comment(i)
  73.         elif rawdata[j] == '[':
  74.             return self.parse_marked_section(i)
  75.         else:
  76.             (decltype, j) = self._scan_name(j, i)
  77.         if j < 0:
  78.             return j
  79.         
  80.         if decltype == 'doctype':
  81.             self._decl_otherchars = ''
  82.         
  83.         while j < n:
  84.             c = rawdata[j]
  85.             if c == '>':
  86.                 data = rawdata[i + 2:j]
  87.                 if decltype == 'doctype':
  88.                     self.handle_decl(data)
  89.                 else:
  90.                     self.unknown_decl(data)
  91.                 return j + 1
  92.             
  93.             if c in '"\'':
  94.                 m = _declstringlit_match(rawdata, j)
  95.                 if not m:
  96.                     return -1
  97.                 
  98.                 j = m.end()
  99.             elif c in 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ':
  100.                 (name, j) = self._scan_name(j, i)
  101.             elif c in self._decl_otherchars:
  102.                 j = j + 1
  103.             elif c == '[':
  104.                 if decltype == 'doctype':
  105.                     j = self._parse_doctype_subset(j + 1, i)
  106.                 elif decltype in ('attlist', 'linktype', 'link', 'element'):
  107.                     self.error("unsupported '[' char in %s declaration" % decltype)
  108.                 else:
  109.                     self.error("unexpected '[' char in declaration")
  110.             else:
  111.                 self.error('unexpected %r char in declaration' % rawdata[j])
  112.             if j < 0:
  113.                 return j
  114.                 continue
  115.         return -1
  116.  
  117.     
  118.     def parse_marked_section(self, i, report = 1):
  119.         rawdata = self.rawdata
  120.         if not rawdata[i:i + 3] == '<![':
  121.             raise AssertionError, 'unexpected call to parse_marked_section()'
  122.         (sectName, j) = self._scan_name(i + 3, i)
  123.         if j < 0:
  124.             return j
  125.         
  126.         if sectName in ('temp', 'cdata', 'ignore', 'include', 'rcdata'):
  127.             match = _markedsectionclose.search(rawdata, i + 3)
  128.         elif sectName in ('if', 'else', 'endif'):
  129.             match = _msmarkedsectionclose.search(rawdata, i + 3)
  130.         else:
  131.             self.error('unknown status keyword %r in marked section' % rawdata[i + 3:j])
  132.         if not match:
  133.             return -1
  134.         
  135.         if report:
  136.             j = match.start(0)
  137.             self.unknown_decl(rawdata[i + 3:j])
  138.         
  139.         return match.end(0)
  140.  
  141.     
  142.     def parse_comment(self, i, report = 1):
  143.         rawdata = self.rawdata
  144.         if rawdata[i:i + 4] != '<!--':
  145.             self.error('unexpected call to parse_comment()')
  146.         
  147.         match = _commentclose.search(rawdata, i + 4)
  148.         if not match:
  149.             return -1
  150.         
  151.         if report:
  152.             j = match.start(0)
  153.             self.handle_comment(rawdata[i + 4:j])
  154.         
  155.         return match.end(0)
  156.  
  157.     
  158.     def _parse_doctype_subset(self, i, declstartpos):
  159.         rawdata = self.rawdata
  160.         n = len(rawdata)
  161.         j = i
  162.         while j < n:
  163.             c = rawdata[j]
  164.             if c == '<':
  165.                 s = rawdata[j:j + 2]
  166.                 if s == '<':
  167.                     return -1
  168.                 
  169.                 if s != '<!':
  170.                     self.updatepos(declstartpos, j + 1)
  171.                     self.error('unexpected char in internal subset (in %r)' % s)
  172.                 
  173.                 if j + 2 == n:
  174.                     return -1
  175.                 
  176.                 if j + 4 > n:
  177.                     return -1
  178.                 
  179.                 if rawdata[j:j + 4] == '<!--':
  180.                     j = self.parse_comment(j, report = 0)
  181.                     if j < 0:
  182.                         return j
  183.                         continue
  184.                     continue
  185.                 
  186.                 (name, j) = self._scan_name(j + 2, declstartpos)
  187.                 if j == -1:
  188.                     return -1
  189.                 
  190.                 if name not in ('attlist', 'element', 'entity', 'notation'):
  191.                     self.updatepos(declstartpos, j + 2)
  192.                     self.error('unknown declaration %r in internal subset' % name)
  193.                 
  194.                 meth = getattr(self, '_parse_doctype_' + name)
  195.                 j = meth(j, declstartpos)
  196.                 if j < 0:
  197.                     return j
  198.                 
  199.             j < 0
  200.             if c == '%':
  201.                 if j + 1 == n:
  202.                     return -1
  203.                 
  204.                 (s, j) = self._scan_name(j + 1, declstartpos)
  205.                 if j < 0:
  206.                     return j
  207.                 
  208.                 if rawdata[j] == ';':
  209.                     j = j + 1
  210.                 
  211.             rawdata[j] == ';'
  212.             if c == ']':
  213.                 j = j + 1
  214.                 while j < n and rawdata[j].isspace():
  215.                     j = j + 1
  216.                 if j < n:
  217.                     if rawdata[j] == '>':
  218.                         return j
  219.                     
  220.                     self.updatepos(declstartpos, j)
  221.                     self.error('unexpected char after internal subset')
  222.                 else:
  223.                     return -1
  224.             j < n
  225.             if c.isspace():
  226.                 j = j + 1
  227.                 continue
  228.             self.updatepos(declstartpos, j)
  229.             self.error('unexpected char %r in internal subset' % c)
  230.         return -1
  231.  
  232.     
  233.     def _parse_doctype_element(self, i, declstartpos):
  234.         (name, j) = self._scan_name(i, declstartpos)
  235.         if j == -1:
  236.             return -1
  237.         
  238.         rawdata = self.rawdata
  239.         if '>' in rawdata[j:]:
  240.             return rawdata.find('>', j) + 1
  241.         
  242.         return -1
  243.  
  244.     
  245.     def _parse_doctype_attlist(self, i, declstartpos):
  246.         rawdata = self.rawdata
  247.         (name, j) = self._scan_name(i, declstartpos)
  248.         c = rawdata[j:j + 1]
  249.         if c == '':
  250.             return -1
  251.         
  252.         if c == '>':
  253.             return j + 1
  254.         
  255.         while None:
  256.             (name, j) = self._scan_name(j, declstartpos)
  257.             if j < 0:
  258.                 return j
  259.             
  260.             c = rawdata[j:j + 1]
  261.             if c == '':
  262.                 return -1
  263.             
  264.             if c == '(':
  265.                 if ')' in rawdata[j:]:
  266.                     j = rawdata.find(')', j) + 1
  267.                 else:
  268.                     return -1
  269.                 while rawdata[j:j + 1].isspace():
  270.                     j = j + 1
  271.                 if not rawdata[j:]:
  272.                     return -1
  273.                 
  274.             else:
  275.                 (name, j) = self._scan_name(j, declstartpos)
  276.             c = rawdata[j:j + 1]
  277.             if not c:
  278.                 return -1
  279.             
  280.             if c in '\'"':
  281.                 m = _declstringlit_match(rawdata, j)
  282.                 if m:
  283.                     j = m.end()
  284.                 else:
  285.                     return -1
  286.                 c = rawdata[j:j + 1]
  287.                 if not c:
  288.                     return -1
  289.                 
  290.             
  291.             if c == '#':
  292.                 if rawdata[j:] == '#':
  293.                     return -1
  294.                 
  295.                 (name, j) = self._scan_name(j + 1, declstartpos)
  296.                 if j < 0:
  297.                     return j
  298.                 
  299.                 c = rawdata[j:j + 1]
  300.                 if not c:
  301.                     return -1
  302.                 
  303.             
  304.             if c == '>':
  305.                 return j + 1
  306.                 continue
  307.             continue
  308.             return None
  309.  
  310.     
  311.     def _parse_doctype_notation(self, i, declstartpos):
  312.         (name, j) = self._scan_name(i, declstartpos)
  313.         if j < 0:
  314.             return j
  315.         
  316.         rawdata = self.rawdata
  317.         while None:
  318.             c = rawdata[j:j + 1]
  319.             if not c:
  320.                 return -1
  321.             
  322.             if c == '>':
  323.                 return j + 1
  324.             
  325.             if c in '\'"':
  326.                 m = _declstringlit_match(rawdata, j)
  327.                 if not m:
  328.                     return -1
  329.                 
  330.                 j = m.end()
  331.                 continue
  332.             (name, j) = self._scan_name(j, declstartpos)
  333.             if j < 0:
  334.                 return j
  335.                 continue
  336.             continue
  337.             return None
  338.  
  339.     
  340.     def _parse_doctype_entity(self, i, declstartpos):
  341.         rawdata = self.rawdata
  342.         if rawdata[i:i + 1] == '%':
  343.             j = i + 1
  344.             while None:
  345.                 c = rawdata[j:j + 1]
  346.                 if not c:
  347.                     return -1
  348.                 
  349.                 if c.isspace():
  350.                     j = j + 1
  351.                     continue
  352.                 break
  353.                 continue
  354.         rawdata[i:i + 1] == '%'
  355.         j = i
  356.         (name, j) = self._scan_name(j, declstartpos)
  357.         if j < 0:
  358.             return j
  359.         
  360.         while None:
  361.             c = self.rawdata[j:j + 1]
  362.             if not c:
  363.                 return -1
  364.             
  365.             if c in '\'"':
  366.                 m = _declstringlit_match(rawdata, j)
  367.                 if m:
  368.                     j = m.end()
  369.                 else:
  370.                     return -1
  371.             if c == '>':
  372.                 return j + 1
  373.                 continue
  374.             (name, j) = self._scan_name(j, declstartpos)
  375.             if j < 0:
  376.                 return j
  377.                 continue
  378.             continue
  379.             return None
  380.  
  381.     
  382.     def _scan_name(self, i, declstartpos):
  383.         rawdata = self.rawdata
  384.         n = len(rawdata)
  385.         if i == n:
  386.             return (None, -1)
  387.         
  388.         m = _declname_match(rawdata, i)
  389.         if m:
  390.             s = m.group()
  391.             name = s.strip()
  392.             if i + len(s) == n:
  393.                 return (None, -1)
  394.             
  395.             return (name.lower(), m.end())
  396.         else:
  397.             self.updatepos(declstartpos, i)
  398.             self.error('expected name token at %r' % rawdata[declstartpos:declstartpos + 20])
  399.  
  400.     
  401.     def unknown_decl(self, data):
  402.         pass
  403.  
  404.  
  405.